From deec0bf25506f5ddae10bedb5b9cbfafc4730db2 Mon Sep 17 00:00:00 2001 From: Georges Basile Stavracas Neto Date: Thu, 24 Jan 2019 13:42:14 -0200 Subject: [PATCH] texture-cache: Replace ClutterTexture by ClutterImage ClutterTexture is a deprecated class that is simultaneously an actor, and the content of the actor. Clutter's new model is to separate painting (via ClutterContent) from actors. Currently, StTextureCache relies on ClutterTexture to store the loaded textures. This not only does not match the latest practices of Clutter, but also generates various compile-time warnings. Port StTextureCache to store ClutterImages instead of storing ClutterTextures. ClutterImage exposes the internal CoglTexture, so no helpers are needed to match the current StTextureCache API. Aspect ratio was dropped, but from my testing, it doesn't change anything. --- src/st/st-icon.c | 11 +- src/st/st-texture-cache.c | 209 +++++++++++++++++++------------------- 2 files changed, 111 insertions(+), 109 deletions(-) diff --git a/src/st/st-icon.c b/src/st/st-icon.c index 5892f8a52..625f2a895 100644 --- a/src/st/st-icon.c +++ b/src/st/st-icon.c @@ -309,11 +309,11 @@ st_icon_update_shadow_pipeline (StIcon *icon) } static void -on_pixbuf_changed (ClutterTexture *texture, - StIcon *icon) +on_content_changed (ClutterActor *actor, + GParamSpec *pspec, + StIcon *icon) { st_icon_clear_shadow_pipeline (icon); - clutter_actor_queue_redraw (CLUTTER_ACTOR (icon)); } static void @@ -340,9 +340,8 @@ st_icon_finish_update (StIcon *icon) st_icon_clear_shadow_pipeline (icon); - /* "pixbuf-change" is actually a misnomer for "texture-changed" */ - g_signal_connect_object (priv->icon_texture, "pixbuf-change", - G_CALLBACK (on_pixbuf_changed), icon, 0); + g_signal_connect_object (priv->icon_texture, "notify::content", + G_CALLBACK (on_content_changed), icon, 0); } } diff --git a/src/st/st-texture-cache.c b/src/st/st-texture-cache.c index 621907111..337d81869 100644 --- a/src/st/st-texture-cache.c +++ b/src/st/st-texture-cache.c @@ -36,7 +36,7 @@ struct _StTextureCachePrivate GtkIconTheme *icon_theme; /* Things that were loaded with a cache policy != NONE */ - GHashTable *keyed_cache; /* char * -> CoglTexture* */ + GHashTable *keyed_cache; /* char * -> ClutterImage* */ GHashTable *keyed_surface_cache; /* char * -> cairo_surface_t* */ /* Presently this is used to de-duplicate requests for GIcons and async URIs. */ @@ -64,20 +64,23 @@ G_DEFINE_TYPE(StTextureCache, st_texture_cache, G_TYPE_OBJECT); * pipeline for an empty texture is full opacity white, which we * definitely don't want. Skip that by setting 0 opacity. */ -static ClutterTexture * -create_default_texture (void) +static ClutterActor * +create_invisible_actor (void) { - ClutterTexture * texture = CLUTTER_TEXTURE (clutter_texture_new ()); - g_object_set (texture, "keep-aspect-ratio", TRUE, "opacity", 0, NULL); - return texture; + return g_object_new (CLUTTER_TYPE_ACTOR, + "opacity", 0, + NULL); } /* Reverse the opacity we added while loading */ static void -set_texture_cogl_texture (ClutterTexture *clutter_texture, CoglTexture *cogl_texture) +set_content_from_image (ClutterActor *actor, + ClutterContent *image) { - clutter_texture_set_cogl_texture (clutter_texture, cogl_texture); - g_object_set (clutter_texture, "opacity", 255, NULL); + g_assert (image && CLUTTER_IS_IMAGE (image)); + + clutter_actor_set_content (actor, image); + clutter_actor_set_opacity (actor, 255); } static void @@ -145,7 +148,7 @@ st_texture_cache_init (StTextureCache *self) G_CALLBACK (on_icon_theme_changed), self); self->priv->keyed_cache = g_hash_table_new_full (g_str_hash, g_str_equal, - g_free, cogl_object_unref); + g_free, g_object_unref); self->priv->keyed_surface_cache = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, @@ -270,7 +273,7 @@ typedef struct { guint width; guint height; guint scale; - GSList *textures; + GSList *actors; GtkIconInfo *icon_info; StIconColors *colors; @@ -294,8 +297,8 @@ texture_load_data_free (gpointer p) if (data->key) g_free (data->key); - if (data->textures) - g_slist_free_full (data->textures, (GDestroyNotify) g_object_unref); + if (data->actors) + g_slist_free_full (data->actors, (GDestroyNotify) g_object_unref); g_free (data); } @@ -464,29 +467,29 @@ load_pixbuf_async_finish (StTextureCache *cache, GAsyncResult *result, GError ** return g_task_propagate_pointer (G_TASK (result), error); } -static CoglTexture * -pixbuf_to_cogl_texture (GdkPixbuf *pixbuf) +static ClutterContent * +pixbuf_to_clutter_image (GdkPixbuf *pixbuf) { - ClutterBackend *backend = clutter_get_default_backend (); - CoglContext *ctx = clutter_backend_get_cogl_context (backend); - CoglError *error = NULL; - CoglTexture2D *texture; - - texture = cogl_texture_2d_new_from_data (ctx, - gdk_pixbuf_get_width (pixbuf), - gdk_pixbuf_get_height (pixbuf), - gdk_pixbuf_get_has_alpha (pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, - gdk_pixbuf_get_rowstride (pixbuf), - gdk_pixbuf_get_pixels (pixbuf), - &error); + ClutterContent *image; + g_autoptr(GError) error = NULL; + + image = clutter_image_new (); + clutter_image_set_data (CLUTTER_IMAGE (image), + gdk_pixbuf_get_pixels (pixbuf), + gdk_pixbuf_get_has_alpha (pixbuf) ? + COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, + gdk_pixbuf_get_width (pixbuf), + gdk_pixbuf_get_height (pixbuf), + gdk_pixbuf_get_rowstride (pixbuf), + &error); if (error) { g_warning ("Failed to allocate texture: %s", error->message); - cogl_error_free (error); + g_clear_object (&image); } - return texture ? COGL_TEXTURE (texture) : NULL; + return image; } static cairo_surface_t * @@ -514,9 +517,9 @@ static void finish_texture_load (AsyncTextureLoadData *data, GdkPixbuf *pixbuf) { + g_autoptr(ClutterContent) image = NULL; GSList *iter; StTextureCache *cache; - CoglTexture *texdata = NULL; cache = data->cache; @@ -525,8 +528,8 @@ finish_texture_load (AsyncTextureLoadData *data, if (pixbuf == NULL) goto out; - texdata = pixbuf_to_cogl_texture (pixbuf); - if (!texdata) + image = pixbuf_to_clutter_image (pixbuf); + if (!image) goto out; if (data->policy != ST_TEXTURE_CACHE_POLICY_NONE) @@ -536,22 +539,18 @@ finish_texture_load (AsyncTextureLoadData *data, if (!g_hash_table_lookup_extended (cache->priv->keyed_cache, data->key, &orig_key, &value)) { - cogl_object_ref (texdata); g_hash_table_insert (cache->priv->keyed_cache, g_strdup (data->key), - texdata); + g_object_ref (image)); } } - for (iter = data->textures; iter; iter = iter->next) + for (iter = data->actors; iter; iter = iter->next) { - ClutterTexture *texture = iter->data; - set_texture_cogl_texture (texture, texdata); + ClutterActor *actor = iter->data; + set_content_from_image (actor, image); } out: - if (texdata) - cogl_object_unref (texdata); - texture_load_data_free (data); } @@ -630,7 +629,7 @@ load_texture_async (StTextureCache *cache, typedef struct { StTextureCache *cache; - ClutterTexture *texture; + ClutterActor *actor; GObject *source; guint notify_signal_id; gboolean weakref_active; @@ -641,9 +640,6 @@ st_texture_cache_reset_texture (StTextureCachePropertyBind *bind, const char *propname) { cairo_surface_t *surface; - CoglTexture *texdata; - ClutterBackend *backend = clutter_get_default_backend (); - CoglContext *ctx = clutter_backend_get_cogl_context (backend); g_object_get (bind->source, propname, &surface, NULL); @@ -652,32 +648,39 @@ st_texture_cache_reset_texture (StTextureCachePropertyBind *bind, (cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32 || cairo_image_surface_get_format (surface) == CAIRO_FORMAT_RGB24)) { - CoglError *error = NULL; - - texdata = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx, - cairo_image_surface_get_width (surface), - cairo_image_surface_get_height (surface), - cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32 ? - COGL_PIXEL_FORMAT_BGRA_8888 : COGL_PIXEL_FORMAT_BGR_888, - cairo_image_surface_get_stride (surface), - cairo_image_surface_get_data (surface), - &error)); - - if (texdata) + ClutterContent *image; + GError *error = NULL; + + image = clutter_actor_get_content (bind->actor); + if (!image || !CLUTTER_IS_IMAGE (image)) + image = clutter_image_new (); + else + g_object_ref (image); + + clutter_image_set_data (CLUTTER_IMAGE (image), + cairo_image_surface_get_data (surface), + cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32 ? + COGL_PIXEL_FORMAT_BGRA_8888 : COGL_PIXEL_FORMAT_BGR_888, + cairo_image_surface_get_width (surface), + cairo_image_surface_get_height (surface), + cairo_image_surface_get_stride (surface), + &error); + + if (image) { - clutter_texture_set_cogl_texture (bind->texture, texdata); - cogl_object_unref (texdata); + clutter_actor_set_content (bind->actor, image); + g_object_unref (image); } else if (error) { g_warning ("Failed to allocate texture: %s", error->message); - cogl_error_free (error); + g_error_free (error); } - clutter_actor_set_opacity (CLUTTER_ACTOR (bind->texture), 255); + clutter_actor_set_opacity (bind->actor, 255); } else - clutter_actor_set_opacity (CLUTTER_ACTOR (bind->texture), 0); + clutter_actor_set_opacity (bind->actor, 0); } static void @@ -703,7 +706,7 @@ st_texture_cache_free_bind (gpointer data) { StTextureCachePropertyBind *bind = data; if (bind->weakref_active) - g_object_weak_unref (G_OBJECT(bind->texture), st_texture_cache_bind_weak_notify, bind); + g_object_weak_unref (G_OBJECT (bind->actor), st_texture_cache_bind_weak_notify, bind); g_free (bind); } @@ -727,17 +730,17 @@ st_texture_cache_bind_cairo_surface_property (StTextureCache *cache, GObject *object, const char *property_name) { - ClutterTexture *texture; + ClutterActor *actor; gchar *notify_key; StTextureCachePropertyBind *bind; - texture = CLUTTER_TEXTURE (clutter_texture_new ()); + actor = clutter_actor_new (); bind = g_new0 (StTextureCachePropertyBind, 1); bind->cache = cache; - bind->texture = texture; + bind->actor = actor; bind->source = object; - g_object_weak_ref (G_OBJECT (texture), st_texture_cache_bind_weak_notify, bind); + g_object_weak_ref (G_OBJECT (actor), st_texture_cache_bind_weak_notify, bind); bind->weakref_active = TRUE; st_texture_cache_reset_texture (bind, property_name); @@ -747,7 +750,7 @@ st_texture_cache_bind_cairo_surface_property (StTextureCache *cache, bind, (GClosureNotify)st_texture_cache_free_bind, 0); g_free (notify_key); - return CLUTTER_ACTOR(texture); + return actor; } /** @@ -802,25 +805,25 @@ st_texture_cache_load (StTextureCache *cache, * is already a request pending, append it to that request to avoid loading * the data multiple times. * - * Returns: %TRUE iff there is already a request pending + * Returns: %TRUE if there is already a request pending */ static gboolean ensure_request (StTextureCache *cache, const char *key, StTextureCachePolicy policy, AsyncTextureLoadData **request, - ClutterActor *texture) + ClutterActor *actor) { - CoglTexture *texdata; + ClutterContent *image; AsyncTextureLoadData *pending; gboolean had_pending; - texdata = g_hash_table_lookup (cache->priv->keyed_cache, key); + image = g_hash_table_lookup (cache->priv->keyed_cache, key); - if (texdata != NULL) + if (image != NULL) { /* We had this cached already, just set the texture and we're done. */ - set_texture_cogl_texture (CLUTTER_TEXTURE (texture), texdata); + set_content_from_image (actor, image); return TRUE; } @@ -838,7 +841,7 @@ ensure_request (StTextureCache *cache, *request = pending; /* Regardless of whether there was a pending request, prepend our texture here. */ - (*request)->textures = g_slist_prepend ((*request)->textures, g_object_ref (texture)); + (*request)->actors = g_slist_prepend ((*request)->actors, g_object_ref (actor)); return had_pending; } @@ -866,7 +869,7 @@ st_texture_cache_load_gicon (StTextureCache *cache, gint scale) { AsyncTextureLoadData *request; - ClutterActor *texture; + ClutterActor *actor; char *gicon_string; char *key; GtkIconTheme *theme; @@ -925,10 +928,10 @@ st_texture_cache_load_gicon (StTextureCache *cache, } g_free (gicon_string); - texture = (ClutterActor *) create_default_texture (); - clutter_actor_set_size (texture, size * scale, size * scale); + actor = create_invisible_actor (); + clutter_actor_set_size (actor, size * scale, size * scale); - if (ensure_request (cache, key, policy, &request, texture)) + if (ensure_request (cache, key, policy, &request, actor)) { /* If there's an outstanding request, we've just added ourselves to it */ g_object_unref (info); @@ -950,27 +953,24 @@ st_texture_cache_load_gicon (StTextureCache *cache, load_texture_async (cache, request); } - return CLUTTER_ACTOR (texture); + return actor; } static ClutterActor * load_from_pixbuf (GdkPixbuf *pixbuf) { - ClutterTexture *texture; - CoglTexture *texdata; + g_autoptr(ClutterContent) image = NULL; + ClutterActor *actor; int width = gdk_pixbuf_get_width (pixbuf); int height = gdk_pixbuf_get_height (pixbuf); - texture = create_default_texture (); + image = pixbuf_to_clutter_image (pixbuf); - clutter_actor_set_size (CLUTTER_ACTOR (texture), width, height); + actor = clutter_actor_new (); + clutter_actor_set_size (actor, width, height); + clutter_actor_set_content (actor, image); - texdata = pixbuf_to_cogl_texture (pixbuf); - - set_texture_cogl_texture (texture, texdata); - - cogl_object_unref (texdata); - return CLUTTER_ACTOR (texture); + return actor; } static void @@ -1218,7 +1218,7 @@ st_texture_cache_load_file_async (StTextureCache *cache, int available_height, int scale) { - ClutterActor *texture; + ClutterActor *actor; AsyncTextureLoadData *request; StTextureCachePolicy policy; gchar *key; @@ -1227,9 +1227,9 @@ st_texture_cache_load_file_async (StTextureCache *cache, policy = ST_TEXTURE_CACHE_POLICY_NONE; /* XXX */ - texture = (ClutterActor *) create_default_texture (); + actor = create_invisible_actor (); - if (ensure_request (cache, key, policy, &request, texture)) + if (ensure_request (cache, key, policy, &request, actor)) { /* If there's an outstanding request, we've just added ourselves to it */ g_free (key); @@ -1252,7 +1252,7 @@ st_texture_cache_load_file_async (StTextureCache *cache, ensure_monitor_for_file (cache, file); - return CLUTTER_ACTOR (texture); + return actor; } static CoglTexture * @@ -1264,34 +1264,37 @@ st_texture_cache_load_file_sync_to_cogl_texture (StTextureCache *cache, int scale, GError **error) { + ClutterContent *image; CoglTexture *texdata; GdkPixbuf *pixbuf; char *key; key = g_strdup_printf (CACHE_PREFIX_FILE "%u", g_file_hash (file)); - texdata = g_hash_table_lookup (cache->priv->keyed_cache, key); + texdata = NULL; + image = g_hash_table_lookup (cache->priv->keyed_cache, key); - if (texdata == NULL) + if (image == NULL) { pixbuf = impl_load_pixbuf_file (file, available_width, available_height, scale, error); if (!pixbuf) goto out; - texdata = pixbuf_to_cogl_texture (pixbuf); + image = pixbuf_to_clutter_image (pixbuf); g_object_unref (pixbuf); - if (!texdata) + if (!image) goto out; if (policy == ST_TEXTURE_CACHE_POLICY_FOREVER) - { - cogl_object_ref (texdata); - g_hash_table_insert (cache->priv->keyed_cache, g_strdup (key), texdata); - } + g_hash_table_insert (cache->priv->keyed_cache, g_strdup (key), image); } - else - cogl_object_ref (texdata); + + /* Because the texture is loaded synchronously, we won't call + * clutter_image_set_data(), so it's safe to use the texture + * of ClutterImage here. */ + texdata = clutter_image_get_texture (CLUTTER_IMAGE (image)); + cogl_object_ref (texdata); ensure_monitor_for_file (cache, file); -- 2.39.5